{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1363d21d",
   "metadata": {},
   "source": [
    "# DAY 53"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99ccb6d",
   "metadata": {},
   "source": [
    "## 一、 GAN对抗生成网络思想"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b0b4e6d",
   "metadata": {},
   "source": [
    "先说一下gan的原理，我们之前就说过，无论是多么复杂的架构设计，你最需要把握的核心点就是：1. 损失从何而来 2. 损失如何定义\n",
    "\n",
    "假设现在有1个造假币的a，和一个警察b，他们都是初始化的神经网络\n",
    "\n",
    "为了让警察能分辨真币，我需要给他看真币的样子，也就是先训练警察知道什么是真币，但是只给他一个真币他也没法训练，我中间得掺杂一些无意义的噪声图片，无意义的肯定不可能是真币，所以他大概可以训练好。此时他就是一个基础的分类模型，能分别真币和假币\n",
    "\n",
    "然后我随机初始化这个造假币的a，我每次给他随机的输入，他会生成不同的假币，每一张假币都会让警察来判断，警察能够分别出真假，如果说你是假的，那么造假币的就要更新参数，如果是真的，那么造假币的参数就不用更新，警察要更新参数。所以后续二者就在不断博弈中进步，知道最后假币专家造假以假乱真，只要更新的轮数多，即使骗不过专家，但是也很棒了。\n",
    "\n",
    "我们把这个造假币的叫做生成器，把这个警察叫做判别器\n",
    "\n",
    "这个过程有点类似于二者互相对抗，所以叫做对抗生成网络，目的就是在对抗中找到一个可以模仿原有数据的模型。生成器基于随机噪声生成样本，判别器对样本（真实数据 + 生成数据）进行分类，双方根据判别结果更新参数（生成器尝试让判别器误判，判别器尝试提高准确率）。\n",
    "\n",
    "他的损失由2部分构成，生成器的损失和判别器的损失。判别器的损失定义在先，生成器的损失定义基于判别器的反馈。\n",
    "1. 判别器的损失：就是分类问题的损失，二分类是二元交叉熵损失BCE（本质分类输出的是概率，并不是非黑即白）\n",
    "\n",
    "2. 生成器的损失：依靠判别器的损失，如果判别器说是假的，生成器的损失就大，反之亦然。\n",
    "\n",
    "判别器损失同时包含 “真实数据判真” 和 “生成数据判假” 两部分，而生成器损失仅针对 “生成数据被判别为真” 的目标。实际训练中，两者的优化是交替进行的（先训判别器，再训生成器）。两者的损失共同推动 GAN 逼近 “以假乱真” 的平衡状态。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd8c5dcd",
   "metadata": {},
   "source": [
    "日常中，我们经常遇到不平衡数据中某一类别样本过少，之前说过结构化数据有smote等过采样方式来提高，图像数据可以数据增强，还可以设置权重等方式来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "046c384c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "使用设备: cuda\n",
      "Using device: cuda\n",
      "成功加载并预处理数据。用于训练的样本数量: 50\n",
      "数据特征维度: 4\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.datasets import load_iris\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "# 设置中文字体支持\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "\n",
    "# 检查GPU是否可用\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"使用设备: {device}\")\n",
    "\n",
    "LATENT_DIM = 10     # 潜在空间的维度，这里根据任务复杂程度任选\n",
    "EPOCHS = 10000      # 训练的回合数，一般需要比较长的时间\n",
    "BATCH_SIZE = 32     # 每批次训练的样本数\n",
    "LR = 0.0002         # 学习率\n",
    "BETA1 = 0.5         # Adam优化器的参数\n",
    "\n",
    "# 检查是否有可用的GPU，否则使用CPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# --- 2. 加载并预处理数据 ---\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "# 只选择 'Setosa' (类别 0)\n",
    "X_class0 = X[y == 0] # 一种简便写法\n",
    "\n",
    "# 数据缩放到 [-1, 1]\n",
    "scaler = MinMaxScaler(feature_range=(-1, 1)) \n",
    "X_scaled = scaler.fit_transform(X_class0) \n",
    " \n",
    "# 转换为 PyTorch Tensor 并创建 DataLoader\n",
    "# 注意需要将数据类型转为 float\n",
    "real_data_tensor = torch.from_numpy(X_scaled).float() \n",
    "dataset = TensorDataset(real_data_tensor)\n",
    "dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "print(f\"成功加载并预处理数据。用于训练的样本数量: {len(X_scaled)}\")\n",
    "print(f\"数据特征维度: {X_scaled.shape[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abbca753",
   "metadata": {},
   "source": [
    "## 二、 生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de8dc37a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# --- 3. 构建模型 ---\n",
    "\n",
    "# (A) 生成器 (Generator)\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Generator, self).__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(LATENT_DIM, 16),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(16, 32),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(32, 4),# 最后的维度只要和目标数据对齐即可\n",
    "            nn.Tanh() # 输出范围是 [-1, 1]\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x) # 因为没有像之前一样做定义x=某些东西，所以现在可以直接输出模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e58ebee",
   "metadata": {},
   "source": [
    "### 2.1 nn.Sequential容器"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06826eb3",
   "metadata": {},
   "source": [
    "这里我们用了torch中的容器这个概念，sequential是一个按顺序存放神经网络的容器，这样写神经网路的属性的时候，把这些内容都写在一个容器中，然后作为属性，后面定义前向传播的视时候会方便很多。\n",
    "\n",
    "除了nn.sequential这种按顺序运算的容器,还有一些其他的容器，比如nn.ModuleList对于消融实验会起到简化代码的作用，有机会我们未来再说。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06b6c882",
   "metadata": {},
   "source": [
    "这种写法很好用，比如像encoder-decoder架构（之前复试课说了），就可以借助这种写法来实现简单的定义前向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "441c7c45",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def forward(self, x):\n",
    "#     x = self.encoder(x)\n",
    "#     x = self.decoder(x)\n",
    "#     return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fefe403",
   "metadata": {},
   "source": [
    "当网络结构不满足线性顺序执行时（如包含残差连接、多分支、条件判断等），必须手动编写forward()方法。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "68047a3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def forward(self, x):\n",
    "#     identity = x\n",
    "#     out = self.conv1(x)\n",
    "#     out = self.relu(out)\n",
    "#     out = self.conv2(out)\n",
    "#     out += identity  # 残差连接（无法用Sequential实现）\n",
    "#     return self.relu(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6702521a",
   "metadata": {},
   "source": [
    "这是一个残差连接的写法，无法用sequential这个容器按顺序搭建。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53b3fcb5",
   "metadata": {},
   "source": [
    "总结：\n",
    "\n",
    "- 对于网络层按线性顺序堆叠（如 MLP、CNN 的主体部分），可以使用 Sequential 模型。\n",
    "- 对于网络包含复杂分支结构（如 ResNet 的残差连接、Inception 的多分支），建议手动编写forward()方法。\n",
    "\n",
    "这两种方式本质上是等价的，但前者更符合模块化编程的思想，能让你的代码更易读、易维护。\n",
    "\n",
    "不得不说，代码其实本质上就是几个常见的运算，但是由于不断封装，具备了各种各样的类、属性、语法糖等等写法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdfed431",
   "metadata": {},
   "source": [
    "## 三、判别器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1dcdb8e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# (B) 判别器 (Discriminator)\n",
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(4, 32),\n",
    "            nn.LeakyReLU(0.2), # LeakyReLU 是 GAN 中的常用选择\n",
    "            nn.Linear(32, 16),\n",
    "            nn.LeakyReLU(0.2), # 负斜率参数为0.2\n",
    "            nn.Linear(16, 1), # 这里最后输出1个神经元,所以用sigmoid激活函数\n",
    "            nn.Sigmoid() # 输出 0 到 1 的概率\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e33296f",
   "metadata": {},
   "source": [
    "### 3.1 分类问题激活函数和损失函数的对应"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a305c5",
   "metadata": {},
   "source": [
    "之前这里说的比较浅，我们再概括下激活函数和损失函数对应的情况：\n",
    "\n",
    "二分类问题,常见的输出有2种\n",
    "\n",
    "\n",
    "1. 单输出 + Sigmoid\n",
    "2.  双输出 + Softmax\n",
    "\n",
    "\n",
    "二者完全等价,一般推荐第一个\n",
    "\n",
    "sigmoid一般对应BCE损失，softmax一般对应 CrossEntropy 损失"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52811a1f",
   "metadata": {},
   "source": [
    "### 3.2 LeakyReLU"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c4ec17e",
   "metadata": {},
   "source": [
    "此外，在昨天的神经网络调参指南中，我们就说到了激活函数的选取，我说还有了LeakyReLU这种形式\n",
    "\n",
    "标准relu: f(x) = max(0, x)  小于0的输入直接置为0,计算简单，能缓解梯度消失问题，引入非线性。存在 “神经元死亡” 问题（当输入为负时，梯度为 0，参数无法更新）\n",
    "\n",
    "LeakyReLU: f(x) = max(0.01x, x)   对负数输入保留一个小的梯度（如0.01倍）,在输入为负时，仍有非零梯度（如 0.01），避免神经元永久死亡\n",
    "\n",
    "\n",
    "许多 GAN 变体（如 DCGAN、WGAN）都默认使用 LeakyReLU，实践证明它能显著提高模型收敛速度和生成质量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e3910da6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator(\n",
      "  (model): Sequential(\n",
      "    (0): Linear(in_features=10, out_features=16, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=16, out_features=32, bias=True)\n",
      "    (3): ReLU()\n",
      "    (4): Linear(in_features=32, out_features=4, bias=True)\n",
      "    (5): Tanh()\n",
      "  )\n",
      ")\n",
      "Discriminator(\n",
      "  (model): Sequential(\n",
      "    (0): Linear(in_features=4, out_features=32, bias=True)\n",
      "    (1): LeakyReLU(negative_slope=0.2)\n",
      "    (2): Linear(in_features=32, out_features=16, bias=True)\n",
      "    (3): LeakyReLU(negative_slope=0.2)\n",
      "    (4): Linear(in_features=16, out_features=1, bias=True)\n",
      "    (5): Sigmoid()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# 实例化模型并移动到指定设备\n",
    "generator = Generator().to(device)\n",
    "discriminator = Discriminator().to(device)\n",
    "\n",
    "print(generator)\n",
    "print(discriminator)\n",
    "\n",
    "# --- 4. 定义损失函数和优化器 ---\n",
    "\n",
    "criterion = nn.BCELoss() # 二元交叉熵损失\n",
    "\n",
    "# 分别为生成器和判别器设置优化器\n",
    "g_optimizer = optim.Adam(generator.parameters(), lr=LR, betas=(BETA1, 0.999))\n",
    "d_optimizer = optim.Adam(discriminator.parameters(), lr=LR, betas=(BETA1, 0.999))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "052184a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- 开始训练 ---\n",
      "Epoch [1000/10000], Discriminator Loss: 1.2934, Generator Loss: 0.8093\n",
      "Epoch [2000/10000], Discriminator Loss: 1.3146, Generator Loss: 0.7411\n",
      "Epoch [3000/10000], Discriminator Loss: 1.3665, Generator Loss: 0.7093\n",
      "Epoch [4000/10000], Discriminator Loss: 1.3775, Generator Loss: 0.6901\n",
      "Epoch [5000/10000], Discriminator Loss: 1.3592, Generator Loss: 0.6998\n",
      "Epoch [6000/10000], Discriminator Loss: 1.3706, Generator Loss: 0.7035\n",
      "Epoch [7000/10000], Discriminator Loss: 1.3499, Generator Loss: 0.7026\n",
      "Epoch [8000/10000], Discriminator Loss: 1.3553, Generator Loss: 0.7325\n",
      "Epoch [9000/10000], Discriminator Loss: 1.3449, Generator Loss: 0.7348\n",
      "Epoch [10000/10000], Discriminator Loss: 1.3182, Generator Loss: 0.7244\n",
      "--- 训练完成 ---\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# --- 5. 执行训练循环 ---\n",
    "\n",
    "print(\"\\n--- 开始训练 ---\")\n",
    "for epoch in range(EPOCHS):\n",
    "    for i, (real_data,) in enumerate(dataloader):\n",
    "        # 将数据移动到设备\n",
    "        real_data = real_data.to(device)\n",
    "        current_batch_size = real_data.size(0)\n",
    "\n",
    "        # 创建真实和虚假的标签\n",
    "        real_labels = torch.ones(current_batch_size, 1).to(device)\n",
    "        fake_labels = torch.zeros(current_batch_size, 1).to(device)\n",
    "\n",
    "        # ---------------------\n",
    "        #  训练判别器\n",
    "        # ---------------------\n",
    "        d_optimizer.zero_grad() # 梯度清零\n",
    "\n",
    "        # (1) 用真实数据训练\n",
    "        real_output = discriminator(real_data)\n",
    "        d_loss_real = criterion(real_output, real_labels)\n",
    "        \n",
    "        # (2) 用假数据训练\n",
    "        noise = torch.randn(current_batch_size, LATENT_DIM).to(device)\n",
    "        # 使用 .detach() 防止在训练判别器时梯度流回生成器，这里我们未来再说\n",
    "        fake_data = generator(noise).detach() \n",
    "        fake_output = discriminator(fake_data)\n",
    "        d_loss_fake = criterion(fake_output, fake_labels)\n",
    "        \n",
    "        # 总损失并反向传播\n",
    "        d_loss = d_loss_real + d_loss_fake\n",
    "        d_loss.backward()\n",
    "        d_optimizer.step()\n",
    "\n",
    "        # ---------------------\n",
    "        #  训练生成器\n",
    "        # ---------------------\n",
    "        g_optimizer.zero_grad() # 梯度清零\n",
    "\n",
    "        # 生成新的假数据，并尝试\"欺骗\"判别器\n",
    "        noise = torch.randn(current_batch_size, LATENT_DIM).to(device)\n",
    "        fake_data = generator(noise)\n",
    "        fake_output = discriminator(fake_data)\n",
    "        \n",
    "        # 计算生成器的损失，目标是让判别器将假数据误判为真(1)\n",
    "        g_loss = criterion(fake_output, real_labels)\n",
    "        \n",
    "        # 反向传播并更新生成器\n",
    "        g_loss.backward()\n",
    "        g_optimizer.step()\n",
    "\n",
    "    # 每 1000 个 epoch 打印一次训练状态\n",
    "    if (epoch + 1) % 1000 == 0:\n",
    "        print(\n",
    "            f\"Epoch [{epoch+1}/{EPOCHS}], \"\n",
    "            f\"Discriminator Loss: {d_loss.item():.4f}, \"\n",
    "            f\"Generator Loss: {g_loss.item():.4f}\"\n",
    "        )\n",
    "\n",
    "print(\"--- 训练完成 ---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a4b7e30",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3e305f54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- 生成并可视化结果 ---\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "前5个真实样本 (Setosa):\n",
      "   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
      "0                5.1               3.5                1.4               0.2\n",
      "1                4.9               3.0                1.4               0.2\n",
      "2                4.7               3.2                1.3               0.2\n",
      "3                4.6               3.1                1.5               0.2\n",
      "4                5.0               3.6                1.4               0.2\n",
      "\n",
      "GAN生成的5个新样本:\n",
      "   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
      "0           4.320492          2.661918           1.386190          0.242133\n",
      "1           4.977553          3.303130           1.497289          0.186877\n",
      "2           4.926282          3.197162           1.510863          0.170230\n",
      "3           4.305457          2.951858           1.087415          0.149636\n",
      "4           5.188134          3.727965           1.434129          0.220814\n"
     ]
    }
   ],
   "source": [
    "# --- 6. 生成新数据并进行可视化对比 ---\n",
    "\n",
    "print(\"\\n--- 生成并可视化结果 ---\")\n",
    "# 将生成器设为评估模式\n",
    "generator.eval()\n",
    "\n",
    "# 使用 torch.no_grad() 来关闭梯度计算\n",
    "with torch.no_grad():\n",
    "    num_new_samples = 50\n",
    "    noise = torch.randn(num_new_samples, LATENT_DIM).to(device)\n",
    "    generated_data_scaled = generator(noise)\n",
    "\n",
    "# 将生成的数据从GPU移到CPU，并转换为numpy数组\n",
    "generated_data_scaled_np = generated_data_scaled.cpu().numpy()\n",
    "\n",
    "# 逆向转换回原始尺度\n",
    "generated_data = scaler.inverse_transform(generated_data_scaled_np)\n",
    "real_data_original_scale = scaler.inverse_transform(X_scaled)\n",
    "\n",
    "# 可视化对比\n",
    "fig, axes = plt.subplots(2, 2, figsize=(12, 10))\n",
    "fig.suptitle('真实数据 vs. GAN生成数据 的特征分布对比 (PyTorch)', fontsize=16)\n",
    "\n",
    "feature_names = iris.feature_names\n",
    "\n",
    "for i, ax in enumerate(axes.flatten()):\n",
    "    ax.hist(real_data_original_scale[:, i], bins=10, density=True, alpha=0.6, label='Real Data')\n",
    "    ax.hist(generated_data[:, i], bins=10, density=True, alpha=0.6, label='Generated Data')\n",
    "    ax.set_title(feature_names[i])\n",
    "    ax.legend()\n",
    "\n",
    "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "plt.show()\n",
    "\n",
    "# 将生成的数据与真实数据并排打印出来看看\n",
    "print(\"\\n前5个真实样本 (Setosa):\")\n",
    "print(pd.DataFrame(real_data_original_scale[:5], columns=feature_names))\n",
    "\n",
    "print(\"\\nGAN生成的5个新样本:\")\n",
    "print(pd.DataFrame(generated_data[:5], columns=feature_names))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68b63405",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "GAN 训练效果的关键指标是 生成数据分布与真实数据分布的重合度：  \n",
    "- 若两者分布高度重叠 → 生成数据质量高，GAN 学得好  \n",
    "- 若分布差异大、峰谷错位明显 → 生成数据存在偏差，GAN 学习不充分  \n",
    "\n",
    "那么如何评价好这个分布情况呢？最好是采取定量指标：KL散度，我们以后有机会再说，主要还使用在图像数据上的，GAN"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "yolov5_new",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
